package com.lile.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Scanner;

/*
 * List:
 * 		ArrayList:
 * 			底层数据结构是数组，查询快，增删慢
 * 			线程不安全，效率高
 * 		Vector:
 * 			底层数据结构是数组，查询快，增删慢
 * 			线程安全，效率低
 * 		LinkedList:
 * 			底层数据结构是链表，查询慢，增删快
 * 			线程不安全，效率高
 * 
 * 面试题：ArrayList，Vector和LinkedList的各自特点?
 * 
 * 思考题：ArrayList，Vector和LinkedList我们到底使用谁呢?
 * 			看情况
 * 			
 * 			要安全吗?
 * 				要：Vector(这个现在也不常用，在Collections里面有新的方式)
 * 				不要：ArrayList和LinkedList
 * 					查询多：ArrayList
 * 					增删多：LinkedList
 * 
 * 		不知道用哪个，就用ArrayList。
 * 
 * 需求：用ArrayList存储字符串并遍历
 */
public class ArrayListDemo {

	public static void main(String[] args) {
		// test1();
		// test2();
		// deleteDuplicateStringInArrayList();
		// test3();
		// test4();
		// randomNumber();
		getMaxNumber();
	}

	// 用ArrayList存储字符串并遍历
	public static void test1() {
		ArrayList<String> arrayList = new ArrayList<String>();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");

		Iterator<String> iterator = arrayList.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println(string);
		}

		System.out.println("==============");

		for (int i = 0; i < arrayList.size(); i++) {
			String s = (String) arrayList.get(i);
			System.out.println(s);
		}
	}

	/*
	 * 需求：存储三个学生对象，并遍历。用两种方式遍历
	 * 
	 * 练习： Vector和LinkedList。 存储字符串并遍历 存储自定义对象并遍历
	 */
	public static void test2() {
		ArrayList<Student> stuArrList = new ArrayList<Student>();

		Student s1 = new Student("朱元璋", 47);

		Student s2 = new Student();
		s2.setName("李世民");
		s2.setAge(68);

		Student s3 = new Student("秦始皇", 38);

		stuArrList.add(s1);
		stuArrList.add(s2);
		stuArrList.add(s3);

		Iterator<Student> it = stuArrList.iterator();
		while (it.hasNext()) {
			Student stu = (Student) it.next();
			System.out.println(stu.getName() + "----" + stu.getAge());
		}

		System.out.println("=============");

		for (int i = 0; i < stuArrList.size(); i++) {
			Student stu = (Student) stuArrList.get(i);
			System.out.println(stu.getName() + "----" + stu.getAge());
		}
	}

	/*
	 * 去除集合中字符串的重复值(字符串的内容相同) 举例：
	 * hello,world,java,android,world,java,javaee,java,java,java,android 结果：
	 * hello,world,java,android,javaee
	 * 
	 * 创建新集合的方式： A:定义集合，存储带重复的元素 B:创建新集合 C:遍历旧集合，获取到旧集合中的每一个元素
	 * D:那旧集合的每一个元素到新集合中去找，看有没有 有：就不添加(不搭理它) 木有：就添加 E:遍历新集合
	 */
	public static void deleteDuplicateStringInArrayList() {
		ArrayList<String> arrayList = new ArrayList<String>();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("android");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("javaee");
		arrayList.add("java");
		arrayList.add("world");

		// ArrayList<String> newArrayList = deleteDuplicateString1(arrayList);
		// Iterator<String> it = newArrayList.iterator();

		deleteDuplicateString2(arrayList);
		Iterator<String> it = arrayList.iterator();

		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
	}

	public static ArrayList<String> deleteDuplicateString1(ArrayList<String> arrayList) {
		ArrayList<String> newArrayList = new ArrayList<String>();

		for (int i = 0; i < arrayList.size(); i++) {
			String s = (String) arrayList.get(i);
			if (!newArrayList.contains(s)) {
				newArrayList.add(s);
			}
		}

		return newArrayList;
	}

	// 和数组排序的选择排序思想一样
	public static void deleteDuplicateString2(ArrayList<String> arrayList) {
		for (int i = 0; i < arrayList.size() - 1; i++) {
			for (int j = i + 1; j < arrayList.size(); j++) {
				if (arrayList.get(j).equals(arrayList.get(i))) {
					arrayList.remove(j);
					j--; // 把元素删除后，还要和当前位置的比较一次
				}
			}
		}
	}

	/*
	 * 去除集合中自定义对象的重复值(对象的成员变量值都相同) Student:name,age 通过简单的分析，我们知道，应该是在判断哪里出现了问题。
	 * 所以，我们应该来看看是如何进行判断的。 要想知道是如何判断的，就必须看判断的方法的源码
	 * 通过查看源码，我们知道集合的contains()方法底层源码依赖的是元素对象的equals()方法
	 * 而默认情况下，元素所属的类继承了Object类的equals()方法，比较的是地址值。
	 * 所以，我们想要比较对象的成员变量值相同，就必须重写equals()方法。
	 */
	public static void test3() {
		// 创建集合对象
		ArrayList<Student> array = new ArrayList<Student>();

		// 创建学生对象
		Student s1 = new Student("林青霞", 28);
		Student s2 = new Student("王祖贤", 27);
		Student s3 = new Student("杨幂", 27);
		Student s4 = new Student("李若彤", 25);
		Student s5 = new Student("张惠妹", 40);
		Student s6 = new Student("赵雅芝", 60);
		Student s7 = new Student("林青霞", 20);
		Student s8 = new Student("林青霞", 28);

		// 把学生对象添加到集合中
		array.add(s1);
		array.add(s2);
		array.add(s3);
		array.add(s4);
		array.add(s5);
		array.add(s6);
		array.add(s7);
		array.add(s8);

		// 创建新集合
		ArrayList<Student> newArrayList = new ArrayList<Student>();

		// 遍历旧集合，获取到旧集合中的每一个元素
		for (int x = 0; x < array.size(); x++) {
			Student s = (Student) array.get(x);
			// 那旧集合的每一个元素到新集合中去找，看有没有
			if (!newArrayList.contains(s)) {
				// 木有：就添加
				newArrayList.add(s);
			}
		}

		// 遍历新集合
		Iterator<Student> it = newArrayList.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}

	/*
	 * 需求：四大名著 三国演义 吕布，典韦，赵云 红楼梦 贾宝玉，林黛玉，王熙凤，秦可卿 水浒传 武松，鲁智深，李逵，卢俊义，索超，吴用 西游记
	 * 白骨精，观音姐姐，孙悟空，牛魔王，红孩儿
	 * 
	 * 我国有四大名著，每部名著里有很多代表性角色。
	 */
	public static void test4() {
		// 三国演义小集合
		ArrayList<String> sgyy = new ArrayList<String>();
		sgyy.add("吕布");
		sgyy.add("典韦");
		sgyy.add("赵云");

		// 红楼梦小集合
		ArrayList<String> hlm = new ArrayList<String>();
		hlm.add("贾宝玉");
		hlm.add("林黛玉");
		hlm.add("王熙凤");
		hlm.add("秦可卿");

		// 水浒传小集合
		ArrayList<String> shz = new ArrayList<String>();
		shz.add("武松");
		shz.add("鲁智深");
		shz.add("李逵");
		shz.add("卢俊义");
		shz.add("索超");
		shz.add("吴用");

		// 西游记小集合
		ArrayList<String> xyj = new ArrayList<String>();
		xyj.add("白骨精");
		xyj.add("观音姐姐");
		xyj.add("孙悟空");
		xyj.add("牛魔王");
		xyj.add("红孩儿");

		// 代表名著的大集合
		ArrayList<ArrayList<String>> sdmz = new ArrayList<ArrayList<String>>();
		sdmz.add(sgyy);
		sdmz.add(hlm);
		sdmz.add(shz);
		sdmz.add(xyj);

		// 遍历集合
		for (ArrayList<String> array : sdmz) {
			for (String s : array) {
				System.out.print(s + " ");
			}
			System.out.println();
		}
	}

	/*
	 * 需求：获取10个1-20之间的随机数，要求不能重复
	 * 
	 * 分析： A:定义一个集合，用于存储产生的随机数 B:定义一个统计变量，初始值是0 C:判断统计变量是否小于10 是：
	 * 产生一个随机，然后判断是在集合中 是：不添加 否：添加到集合 否：结束 D:遍历集合
	 */
	public static void randomNumber() {
		ArrayList<Integer> arrayList = new ArrayList<Integer>();

		int count = 0;

		while (count < 10) {
			int randomNumber = (int) (Math.random() * 20) + 1;

			if (!arrayList.contains(randomNumber)) {
				arrayList.add(randomNumber);
				count++;
			}
		}

		for (Integer integer : arrayList) {
			System.out.println(integer);
		}
	}

	/*
	 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
	 * 
	 * 分析： A:定义集合，用于存储多个数据 B:循环键盘录入数据，用while(true){} C:判断键盘录入的数据是否是0 是：break
	 * 否：添加到集合 D:把集合转成数组 E:对数组进行排序(升序) F:获取数组中的最后一个元素即可
	 * 
	 */
	public static void getMaxNumber() {
		ArrayList<Integer> arrayList = new ArrayList<Integer>();

		Scanner sc = new Scanner(System.in);

		while (true) {
			System.out.println("input number:");
			int number = sc.nextInt();

			if (number == 0) {
				break;
			} else {
				arrayList.add(number);
			}
		}

		// public <T> T[] toArray​(T[] a)
		Integer[] iArr = new Integer[arrayList.size()];
		Integer[] integers = arrayList.toArray(iArr);

		Arrays.sort(integers);

		System.out.println("最大值是：" + integers[integers.length - 1]);
	}
}

/*
 * public String toString() { //this -- array Iterator<E> it = this.iterator();
 * if (! it.hasNext()) return "[]";
 * 
 * StringBuilder sb = new StringBuilder(); sb.append('['); for (;;) { E e =
 * it.next(); sb.append(e == this ? "(this Collection)" : e); if (!
 * it.hasNext()) return sb.append(']').toString(); sb.append(',').append(' '); }
 * }
 */
